const db = require('../../MySql')
const { formatDateTime } = require('../utils/dateUtils')

/**
 * 考试模型类
 * 对应数据库中的 el_exam 表
 * 用于封装考试相关的数据和业务逻辑
 */
class el_exam {
    /**
     * 构造函数 - 创建考试对象实例
     * @param {string} id - 考试ID，唯一标识符
     * @param {string} title - 考试标题，描述考试内容的简短标题
     * @param {string} content - 考试内容，详细的考试说明或要求
     * @param {number} open_type - 开放类型，控制考试访问权限（0-私有，1-公开等）
     * @param {number} state - 考试状态
     * @param {number} time_limit - 时间限制（分钟），0表示无时间限制
     * @param {string} start_time - 考试开始时间，格式为YYYY-MM-DD HH:mm:ss
     * @param {string} end_time - 考试结束时间，格式为YYYY-MM-DD HH:mm:ss
     * @param {string} create_time - 创建时间，记录考试创建的时间戳
     * @param {string} update_time - 更新时间，记录考试最后修改的时间戳
     * @param {number} total_score - 考试总分，所有题目的分数总和
     * @param {number} total_time - 总时长（分钟），预计完成考试所需时间
     * @param {number} qualify_score - 及格分数，通过考试所需的最低分数
     */
    constructor(id, title, content, open_type, state, time_limit, start_time, end_time, create_time, update_time, total_score, total_time, qualify_score) {
        this.id = id;
        this.title = title;
        this.content = content;
        this.open_type = open_type;
        this.state = state;
        this.time_limit = time_limit;
        this.start_time = start_time;
        this.end_time = end_time;
        this.create_time = create_time;
        this.update_time = update_time;
        this.total_score = total_score;
        this.total_time = total_time;
        this.qualify_score = qualify_score;
    }

    //
    static async findExamAll(current=1,size=10){
        const offset = (current - 1) * size;
        const [results] = await db.query('select * from el_exam limit ?,?',[offset,size]) 
        return results
    }


    /**
     * 根据考试ID查询考试信息
     * @param {string} examId - 考试ID
     * @returns {Promise<el_exam|null>} 考试实例或null（如果不存在）,返回第一个结果（单个考试对象）
     */
    static async findExamById(examId){
        const [results] = await db.query('select * from el_exam where id=?',[examId])
        
        // 如果没有查询到结果，返回null
        if (results.length === 0) {
            return null;
        }
        
        // 只返回第一个结果（单个考试对象）
        const item = results[0];
        return new el_exam(
            item.id,
            item.title,
            item.content,
            item.open_type,
            item.state,
            item.time_limit,
            formatDateTime(item.start_time),
            formatDateTime(item.end_time),
            formatDateTime(item.create_time),
            formatDateTime(item.update_time),
            item.total_score,
            item.total_time,
            item.qualify_score
        );
    }


    //根据openType，title查询考试列表
    static async findExamsByOpenTypeAndTitle(open_type,title){

        let sql=`select * from el_exam where open_type=? `
        if(title){
            sql+=` and title like '%${title}%'`
        }
        sql+=` order by id desc`

        // 执行SQL查询，获取所有用户数据
        const [results] = await db.query(sql,[open_type])

        // 将查询结果映射为sys_user对象实例
        return results.map(item => new el_exam(
            item.id,
            item.title,
            item.content,
            item.open_type,
            item.state,
            item.time_limit,
            formatDateTime(item.start_time),
            formatDateTime(item.end_time),
            formatDateTime(item.create_time),
            formatDateTime(item.update_time),
            item.total_score,
            item.total_time,
            item.qualify_score
        ))
    }

    //根据考试ID更新考试状态
    static async updateExamStatus(examId,state){
        const sql=`update el_exam set state=?,update_time=now() where id=?`
        await db.query(sql,[state,examId])
    }


}

module.exports = el_exam;